A common activity in general purpose computing is the filling of all memory locations within a given memory region with a given constant value. For example, memset is a standard subroutine to perform such filling. Decompressing a run-length encoding is an example that may use memset to fill an arbitrary region of memory with an arbitrary repeating value.
A newly allocated memory region may typically be initially cleared by filling all of its memory locations with zero, as specified by standard memory allocation subroutines such as calloc. For example, when only one execution thread is utilized, up to 90% of the time needed to allocate a virtual memory page may be spent zero filling the allocation. Page clearing is important because a newly allocated physical page of memory may contain meaningless garbage values, either from a prior use or as an electrical accident from when a computer was powered on.
An object oriented language may implicitly fill memory with a constant for a newly constructed object. For example depending on the element type of a Java array, the array may be initially filled with zero, null, or false. As such, memory filling may be an important activity at all levels of processing abstraction, from memory pages allocated by an operating system, to buffers allocated by a standard subroutine, to objects constructed by a high level language.
A performance problem at all of these levels is that memory filling is typically performed by a single execution thread, thereby limiting the throughput of the filling to less than the processing throughput of the host computer. As such, memory filling typically underutilizes the host computer, which can cause some available hardware to idle.